home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / Q-R / RIFF File Format / MAZlib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-07-29  |  3.6 KB  |  266 lines  |  [TEXT/KAHL]
  1. /*
  2. mod 12 4 86 tsh - inttotext
  3. mod 10 18 86 tsh - LSC 1.41 version
  4. MOD 07-18-86 MAZ - transportable MAZlib functions for lightspeedC
  5. */
  6.  
  7. #include "MAZlib.h"
  8.  
  9. short texttoint(str)
  10. char *str;
  11.     {
  12.     bool signed;
  13.     short sum;
  14.     char *p;
  15.  
  16.     /* collect an integer */
  17.     p = str;
  18.     signed = false;
  19.     if (*p == '-')
  20.         {
  21.         p++;
  22.         signed = true;
  23.         }
  24.     sum = 0;
  25.     for (;*p;p++)
  26.         {
  27.         if (*p < '0' || *p > '9')
  28.             continue;
  29.         sum *= 10;
  30.         sum += *p - '0';
  31.         }
  32.     /* and return number */
  33.     if (signed)
  34.         sum = -sum;
  35.     return(sum);
  36.     }
  37.  
  38. /* append a short integer to a string (returns end of string) */
  39. char *inttotext(str, num)
  40. char *str;
  41. register short num;
  42.     {
  43.     register short i, divr;
  44.     register char *p;
  45.     bool digits_yet;
  46.  
  47.     digits_yet = false;
  48.     p = str;
  49.     divr = 10000;
  50.     if (num < 0)
  51.         {
  52.         *p++ = '-';
  53.         num = -num;
  54.         }
  55.     while (divr >= 10)
  56.         {
  57.         if (num >= divr || digits_yet)
  58.             {
  59.             i = num/divr;
  60.             num -= (i*divr);
  61.             *p++ = '0' + i;
  62.             digits_yet = true;
  63.             }
  64.         divr /= 10;
  65.         }
  66.     *p++ = '0' + num;
  67.     *p = 0;
  68.     return(p);
  69.     }
  70.  
  71. char *cpystr(p,s)
  72. register char *p, *s;
  73.     {
  74.     for (;*s;p++,s++)
  75.         *p = *s;
  76.     *p = '\0';
  77.     return(p);
  78.     }
  79.  
  80. #if 0
  81. /* now in assembly code */
  82. cpybuf(d,s,len)
  83. register char *d, *s;
  84. register short len;
  85.     {
  86.     if (d < s || d > s + len)
  87.         {
  88.         /* forwards move */
  89.         for (;len > 0;len--,d++,s++)
  90.             *d = *s;
  91.         }
  92.     else
  93.         {
  94.         /* backwards move */
  95.         d += len;
  96.         s += len;
  97.         for (;len > 0;len--)
  98.             {
  99.             d--;
  100.             s--;
  101.             *d = *s;
  102.             }
  103.         }
  104.     }
  105.  
  106. longcpybuf(d,s,len)
  107. register char *d, *s;
  108. register long len;
  109.     {
  110.     if (d < s || d > s + len)
  111.         {
  112.         /* forwards move */
  113.         for (;len > 0;len--,d++,s++)
  114.             *d = *s;
  115.         }
  116.     else
  117.         {
  118.         /* backwards move */
  119.         d += len;
  120.         s += len;
  121.         for (;len > 0;len--)
  122.             {
  123.             d--;
  124.             s--;
  125.             *d = *s;
  126.             }
  127.         }
  128.     }
  129. #endif
  130.  
  131. /* compare two char buffers */
  132. bool cmpbuf(p,q,len)
  133. register char *p, *q;
  134. register short len;
  135.     {
  136.     for (;len > 0;len--,p++,q++)
  137.         if (*p != *q)
  138.             return(false);
  139.     return(true);
  140.     }
  141.  
  142. #if 0
  143. /* now in assembly code */
  144. fillbuffer(p,len,c)
  145. register char *p;
  146. register short len;
  147. register char c;
  148.     {
  149.     for (;len > 0;len--,p++)
  150.         *p = c;
  151.     }
  152.  
  153. longfillbuffer(p,len,c)
  154. register char *p;
  155. register long len;
  156. register char c;
  157.     {
  158.     for (;len > 0;len--,p++)
  159.         *p = c;
  160.     }
  161. #endif
  162.  
  163. upper(p,len)
  164. register char *p;
  165. register short len;
  166.     {
  167.     for (;len > 0;len--,p++)
  168.         if (*p >= 'a' && *p <= 'z')
  169.             *p -= 'a' - 'A';
  170.     }
  171.  
  172. lower(p,len)
  173. register char *p;
  174. register short len;
  175.     {
  176.     for (;len > 0;len--,p++)
  177.         if (*p >= 'A' && *p <= 'Z')
  178.             *p += 'a' - 'A';
  179.     }
  180.  
  181. /* search for char c in string s; if found, return its index. if not, */
  182. /* return the index of the null. */
  183. short scnstr(s,c)
  184. register char *s;
  185. register char c;
  186.     {
  187.     register char *p;
  188.  
  189.     for (p = s;*s;s++)
  190.         if (*s == c)
  191.             break;
  192.     return(s - p);
  193.     }
  194.  
  195. insqueue(p,e)
  196. register queue *p, *e;
  197.     {
  198.     queue *n;
  199.  
  200.     n = p->que_next;
  201.     e->que_next = n;
  202.     e->que_prev = p;
  203.     p->que_next = e;
  204.     n->que_prev = e;
  205.     }
  206.  
  207. remqueue(e)
  208. register queue *e;
  209.     {
  210.     e->que_prev->que_next = e->que_next;
  211.     e->que_next->que_prev = e->que_prev;
  212.     }
  213.  
  214. initqueue(qp)
  215. register queue *qp;
  216.     {
  217.     qp->que_next = qp;
  218.     qp->que_prev = qp;
  219.     }
  220.  
  221. bool emptyqueue(qp)
  222. register queue *qp;
  223.     {
  224.     if (qp->que_next == qp)
  225.         return(true);
  226.     return(false);
  227.     }
  228.  
  229. short countqueue(qp)
  230. register queue *qp;
  231.     {
  232.     register queue *e;
  233.     register short i;
  234.  
  235.     for (i = 0,e = qp->que_next;e != qp;e = e->que_next,i++)
  236.         ;
  237.     return(i);
  238.     }
  239.  
  240. short ffset(p,n,o)
  241. register char *p;
  242. register short n;
  243. register short o;
  244.     {
  245.     register short i;
  246.  
  247.     for (i = o;i < n;i++)
  248.         if (BitTst(p,i))
  249.             break;
  250.     return(i);
  251.     }
  252.  
  253. short rotate(i,count)
  254. register unsigned short i;
  255. register short count;
  256.     {
  257.     register short k, j;
  258.  
  259.     count &= 0x000F; /* mask to 16 bits */
  260.     if (count == 0)
  261.         return(i);
  262.     k = i<<count;
  263.     j = i>>(16-count);
  264.     return(k|j);
  265.     }
  266.